home *** CD-ROM | disk | FTP | other *** search
/ EuroCD 3 / EuroCD 3.iso / Games / Doom / ADoom-0.8 / ADoom_src / r_draw.c < prev    next >
C/C++ Source or Header  |  1998-06-24  |  24KB  |  1,072 lines
  1. // Emacs style mode select   -*- C++ -*- 
  2. //-----------------------------------------------------------------------------
  3. //
  4. // $Id:$
  5. //
  6. // Copyright (C) 1993-1996 by id Software, Inc.
  7. //
  8. // This source is available for distribution and/or modification
  9. // only under the terms of the DOOM Source Code License as
  10. // published by id Software. All rights reserved.
  11. //
  12. // The source is distributed in the hope that it will be useful,
  13. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. // FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
  15. // for more details.
  16. //
  17. // $Log:$
  18. //
  19. // DESCRIPTION:
  20. //    The actual span/column drawing functions.
  21. //    Here find the main potential for optimization,
  22. //     e.g. inline assembly, different algorithms.
  23. //
  24. //-----------------------------------------------------------------------------
  25.  
  26.  
  27. static const char
  28. rcsid[] = "$Id: r_draw.c,v 1.4 1997/02/03 16:47:55 b1 Exp $";
  29.  
  30.  
  31. #include "doomdef.h"
  32.  
  33. #include "i_system.h"
  34. #include "z_zone.h"
  35. #include "w_wad.h"
  36.  
  37. #include "r_local.h"
  38.  
  39. // Needs access to LFB (guess what).
  40. #include "v_video.h"
  41.  
  42. // State.
  43. #include "doomstat.h"
  44.  
  45.  
  46. // ?
  47. #define MAXWIDTH            1120
  48. #define MAXHEIGHT            832
  49.  
  50. // status bar height at bottom of screen
  51. #define SBARHEIGHT        32
  52.  
  53. //
  54. // All drawing to the view buffer is accomplished in this file.
  55. // The other refresh files only know about ccordinates,
  56. //  not the architecture of the frame buffer.
  57. // Conveniently, the frame buffer is a linear one,
  58. //  and we need only the base address,
  59. //  and the total size == width*height*depth/8.,
  60. //
  61.  
  62.  
  63. byte*        viewimage; 
  64. int        viewwidth;
  65. int        scaledviewwidth;
  66. int        viewheight;
  67. int        viewwindowx;
  68. int        viewwindowy; 
  69. byte*        ylookup[MAXHEIGHT]; 
  70. int        columnofs[MAXWIDTH]; 
  71.  
  72. // Color tables for different players,
  73. //  translate a limited part to another
  74. //  (color ramps used for  suit colors).
  75. //
  76. FAR byte    translations[3][256];    
  77.  
  78.  
  79.  
  80.  
  81. //
  82. // R_DrawColumn
  83. // Source is the top of the column to scale.
  84. //
  85. lighttable_t*        dc_colormap; 
  86. int            dc_x; 
  87. int            dc_yl; 
  88. int            dc_yh; 
  89. fixed_t            dc_iscale; 
  90. fixed_t            dc_texturemid;
  91.  
  92. // first pixel in a column (possibly virtual) 
  93. byte*            dc_source;        
  94.  
  95. // just for profiling 
  96. int            dccount;
  97.  
  98. //
  99. // A column is a vertical slice/span from a wall texture that,
  100. //  given the DOOM style restrictions on the view orientation,
  101. //  will always have constant z depth.
  102. // Thus a special case loop for very fast rendering can
  103. //  be used. It has also been used with Wolfenstein 3D.
  104. // 
  105. // UNUSED.
  106. #ifndef AMIGA
  107. void R_DrawColumn (void) 
  108. { 
  109.     int            count; 
  110.     byte*        dest; 
  111.     fixed_t        frac;
  112.     fixed_t        fracstep;     
  113.  
  114.     count = dc_yh - dc_yl; 
  115.  
  116.     // Zero length, column does not exceed a pixel.
  117.     if (count < 0) 
  118.     return; 
  119.                  
  120. #ifdef RANGECHECK 
  121.     if ((unsigned)dc_x >= SCREENWIDTH
  122.     || dc_yl < 0
  123.     || dc_yh >= SCREENHEIGHT) 
  124.     I_Error ("R_DrawColumn: %i to %i at %i", dc_yl, dc_yh, dc_x); 
  125. #endif 
  126.  
  127.     // Framebuffer destination address.
  128.     // Use ylookup LUT to avoid multiply with ScreenWidth.
  129.     // Use columnofs LUT for subwindows? 
  130.     dest = ylookup[dc_yl] + columnofs[dc_x];  
  131.  
  132.     // Determine scaling,
  133.     //  which is the only mapping to be done.
  134.     fracstep = dc_iscale; 
  135.     frac = dc_texturemid + (dc_yl-centery)*fracstep; 
  136.  
  137.     // Inner loop that does the actual texture mapping,
  138.     //  e.g. a DDA-lile scaling.
  139.     // This is as fast as it gets.
  140.     do 
  141.     {
  142.     // Re-map color indices from wall texture column
  143.     //  using a lighting/special effects LUT.
  144.     *dest = dc_colormap[dc_source[(frac>>FRACBITS)&127]];
  145.     
  146.     dest += SCREENWIDTH; 
  147.     frac += fracstep;
  148.     
  149.     } while (count--); 
  150. } 
  151. #endif
  152.  
  153.  
  154.  
  155. // UNUSED.
  156. // Loop unrolled.
  157. #if 0
  158. void R_DrawColumn (void) 
  159. { 
  160.     int            count; 
  161.     byte*        source;
  162.     byte*        dest;
  163.     byte*        colormap;
  164.     
  165.     unsigned        frac;
  166.     unsigned        fracstep;
  167.     unsigned        fracstep2;
  168.     unsigned        fracstep3;
  169.     unsigned        fracstep4;     
  170.  
  171.     count = dc_yh - dc_yl + 1; 
  172.  
  173.     source = dc_source;
  174.     colormap = dc_colormap;         
  175.     dest = ylookup[dc_yl] + columnofs[dc_x];  
  176.      
  177.     fracstep = dc_iscale<<9; 
  178.     frac = (dc_texturemid + (dc_yl-centery)*dc_iscale)<<9; 
  179.  
  180.     fracstep2 = fracstep+fracstep;
  181.     fracstep3 = fracstep2+fracstep;
  182.     fracstep4 = fracstep3+fracstep;
  183.     
  184.     while (count >= 8) 
  185.     { 
  186.     dest[0] = colormap[source[frac>>25]]; 
  187.     dest[SCREENWIDTH] = colormap[source[(frac+fracstep)>>25]]; 
  188.     dest[SCREENWIDTH*2] = colormap[source[(frac+fracstep2)>>25]]; 
  189.     dest[SCREENWIDTH*3] = colormap[source[(frac+fracstep3)>>25]];
  190.     
  191.     frac += fracstep4; 
  192.  
  193.     dest[SCREENWIDTH*4] = colormap[source[frac>>25]]; 
  194.     dest[SCREENWIDTH*5] = colormap[source[(frac+fracstep)>>25]]; 
  195.     dest[SCREENWIDTH*6] = colormap[source[(frac+fracstep2)>>25]]; 
  196.     dest[SCREENWIDTH*7] = colormap[source[(frac+fracstep3)>>25]]; 
  197.  
  198.     frac += fracstep4; 
  199.     dest += SCREENWIDTH*8; 
  200.     count -= 8;
  201.     } 
  202.     
  203.     while (count > 0)
  204.     { 
  205.     *dest = colormap[source[frac>>25]]; 
  206.     dest += SCREENWIDTH; 
  207.     frac += fracstep; 
  208.     count--;
  209.     } 
  210. }
  211. #endif
  212.  
  213.  
  214. #ifndef AMIGA
  215. void R_DrawColumnLow (void) 
  216. { 
  217.     int            count; 
  218.     byte*        dest; 
  219.     byte*        dest2;
  220.     fixed_t        frac;
  221.     fixed_t        fracstep;     
  222.  
  223.     count = dc_yh - dc_yl; 
  224.  
  225.     // Zero length.
  226.     if (count < 0) 
  227.     return; 
  228.                  
  229. #ifdef RANGECHECK 
  230.     if ((unsigned)dc_x >= SCREENWIDTH
  231.     || dc_yl < 0
  232.     || dc_yh >= SCREENHEIGHT)
  233.     {
  234.     
  235.     I_Error ("R_DrawColumn: %i to %i at %i", dc_yl, dc_yh, dc_x);
  236.     }
  237.     //    dccount++; 
  238. #endif 
  239.     // Blocky mode, need to multiply by 2.
  240.     dc_x <<= 1;
  241.     
  242.     dest = ylookup[dc_yl] + columnofs[dc_x];
  243.     dest2 = ylookup[dc_yl] + columnofs[dc_x+1];
  244.     
  245.     fracstep = dc_iscale; 
  246.     frac = dc_texturemid + (dc_yl-centery)*fracstep;
  247.     
  248.     do 
  249.     {
  250.     // Hack. Does not work corretly.
  251.     *dest2 = *dest = dc_colormap[dc_source[(frac>>FRACBITS)&127]];
  252.     dest += SCREENWIDTH;
  253.     dest2 += SCREENWIDTH;
  254.     frac += fracstep; 
  255.  
  256.     } while (count--);
  257. }
  258. #endif
  259.  
  260.  
  261. //
  262. // Spectre/Invisibility.
  263. //
  264. #ifndef AMIGA
  265. #define FUZZTABLE       50 
  266. #else
  267. #define FUZZTABLE       250
  268. #endif
  269. #define FUZZOFF    (SCREENWIDTH)
  270.  
  271.  
  272. int    fuzzoffset[FUZZTABLE] =
  273. {
  274.     FUZZOFF,-FUZZOFF,FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,
  275.     FUZZOFF,FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,
  276.     FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,-FUZZOFF,-FUZZOFF,-FUZZOFF,
  277.     FUZZOFF,-FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,
  278.     FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,-FUZZOFF,FUZZOFF,
  279.     FUZZOFF,-FUZZOFF,-FUZZOFF,-FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,
  280.     FUZZOFF,FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,FUZZOFF 
  281. #ifdef AMIGA
  282.     ,FUZZOFF,-FUZZOFF,FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,
  283.     FUZZOFF,FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,
  284.     FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,-FUZZOFF,-FUZZOFF,-FUZZOFF,
  285.     FUZZOFF,-FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,
  286.     FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,-FUZZOFF,FUZZOFF,
  287.     FUZZOFF,-FUZZOFF,-FUZZOFF,-FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,
  288.     FUZZOFF,FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,FUZZOFF,
  289.     FUZZOFF,-FUZZOFF,FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,
  290.     FUZZOFF,FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,
  291.     FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,-FUZZOFF,-FUZZOFF,-FUZZOFF,
  292.     FUZZOFF,-FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,
  293.     FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,-FUZZOFF,FUZZOFF,
  294.     FUZZOFF,-FUZZOFF,-FUZZOFF,-FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,
  295.     FUZZOFF,FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,FUZZOFF,
  296.     FUZZOFF,-FUZZOFF,FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,
  297.     FUZZOFF,FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,
  298.     FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,-FUZZOFF,-FUZZOFF,-FUZZOFF,
  299.     FUZZOFF,-FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,
  300.     FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,-FUZZOFF,FUZZOFF,
  301.     FUZZOFF,-FUZZOFF,-FUZZOFF,-FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,
  302.     FUZZOFF,FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,FUZZOFF,
  303.     FUZZOFF,-FUZZOFF,FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,
  304.     FUZZOFF,FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,
  305.     FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,-FUZZOFF,-FUZZOFF,-FUZZOFF,
  306.     FUZZOFF,-FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,
  307.     FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,-FUZZOFF,FUZZOFF,
  308.     FUZZOFF,-FUZZOFF,-FUZZOFF,-FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,
  309.     FUZZOFF,FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,FUZZOFF
  310. #endif
  311. }; 
  312.  
  313.  
  314. int    fuzzpos = 0; 
  315.  
  316.  
  317. #ifndef AMIGA
  318.  
  319. //
  320. // Framebuffer postprocessing.
  321. // Creates a fuzzy image by copying pixels
  322. //  from adjacent ones to left and right.
  323. // Used with an all black colormap, this
  324. //  could create the SHADOW effect,
  325. //  i.e. spectres and invisible players.
  326. //
  327. void R_DrawFuzzColumn (void) 
  328. { 
  329.     int            count; 
  330.     byte*        dest; 
  331.     fixed_t        frac;
  332.     fixed_t        fracstep;     
  333.  
  334.     // Adjust borders. Low... 
  335.     if (!dc_yl) 
  336.     dc_yl = 1;
  337.  
  338.     // .. and high.
  339.     if (dc_yh == viewheight-1) 
  340.     dc_yh = viewheight - 2; 
  341.          
  342.     count = dc_yh - dc_yl; 
  343.  
  344.     // Zero length.
  345.     if (count < 0) 
  346.     return; 
  347.  
  348.     
  349. #ifdef RANGECHECK 
  350.     if ((unsigned)dc_x >= SCREENWIDTH
  351.     || dc_yl < 0 || dc_yh >= SCREENHEIGHT)
  352.     {
  353.     I_Error ("R_DrawFuzzColumn: %i to %i at %i",
  354.          dc_yl, dc_yh, dc_x);
  355.     }
  356. #endif
  357.  
  358.  
  359.     // Keep till detailshift bug in blocky mode fixed,
  360.     //  or blocky mode removed.
  361.     /* WATCOM code 
  362.     if (detailshift)
  363.     {
  364.     if (dc_x & 1)
  365.     {
  366.         outpw (GC_INDEX,GC_READMAP+(2<<8) ); 
  367.         outp (SC_INDEX+1,12); 
  368.     }
  369.     else
  370.     {
  371.         outpw (GC_INDEX,GC_READMAP); 
  372.         outp (SC_INDEX+1,3); 
  373.     }
  374.     dest = destview + dc_yl*80 + (dc_x>>1); 
  375.     }
  376.     else
  377.     {
  378.     outpw (GC_INDEX,GC_READMAP+((dc_x&3)<<8) ); 
  379.     outp (SC_INDEX+1,1<<(dc_x&3)); 
  380.     dest = destview + dc_yl*80 + (dc_x>>2); 
  381.     }*/
  382.  
  383.     
  384.     // Does not work with blocky mode.
  385.     dest = ylookup[dc_yl] + columnofs[dc_x];
  386.  
  387.     // Looks familiar.
  388.     fracstep = dc_iscale; 
  389.     frac = dc_texturemid + (dc_yl-centery)*fracstep; 
  390.  
  391.     // Looks like an attempt at dithering,
  392.     //  using the colormap #6 (of 0-31, a bit
  393.     //  brighter than average).
  394.     do 
  395.     {
  396.     // Lookup framebuffer, and retrieve
  397.     //  a pixel that is either one column
  398.     //  left or right of the current one.
  399.     // Add index from colormap to index.
  400.     *dest = colormaps[6*256+dest[fuzzoffset[fuzzpos]]]; 
  401.  
  402.     // Clamp table lookup index.
  403.     if (++fuzzpos == FUZZTABLE) 
  404.         fuzzpos = 0;
  405.     
  406.     dest += SCREENWIDTH;
  407.  
  408.     frac += fracstep; 
  409.     } while (count--); 
  410. } 
  411. #endif
  412.  
  413.   
  414.  
  415.  
  416. #ifndef AMIGA
  417.  
  418. //
  419. // Framebuffer postprocessing.
  420. // Creates a fuzzy image by copying pixels
  421. //  from adjacent ones to left and right.
  422. // Used with an all black colormap, this
  423. //  could create the SHADOW effect,
  424. //  i.e. spectres and invisible players.
  425. //
  426. void R_DrawFuzzColumnLow (void) 
  427. { 
  428.     int            count; 
  429.     byte*        dest; 
  430.     byte*        dest2; 
  431.     fixed_t        frac;
  432.     fixed_t        fracstep;     
  433.  
  434.     // Adjust borders. Low... 
  435.     if (!dc_yl) 
  436.     dc_yl = 1;
  437.  
  438.     // .. and high.
  439.     if (dc_yh == viewheight-1) 
  440.     dc_yh = viewheight - 2; 
  441.          
  442.     count = dc_yh - dc_yl; 
  443.  
  444.     // Zero length.
  445.     if (count < 0) 
  446.     return; 
  447.  
  448.     
  449. #ifdef RANGECHECK 
  450.     if (((unsigned)dc_x << 1) >= SCREENWIDTH
  451.     || dc_yl < 0 || dc_yh >= SCREENHEIGHT)
  452.     {
  453.     I_Error ("R_DrawFuzzColumn: %i to %i at %i",
  454.          dc_yl, dc_yh, dc_x);
  455.     }
  456. #endif
  457.  
  458.  
  459.     // Does not work with blocky mode.
  460.     dest = ylookup[dc_yl] + columnofs[dc_x << 1];
  461.     dest2 = ylookup[dc_yl] + columnofs[(dc_x << 1) + 1];
  462.  
  463.     // Looks familiar.
  464.     fracstep = dc_iscale;
  465.     frac = dc_texturemid + (dc_yl-centery)*fracstep;
  466.  
  467.     // Looks like an attempt at dithering,
  468.     //  using the colormap #6 (of 0-31, a bit
  469.     //  brighter than average).
  470.     do 
  471.     {
  472.     // Lookup framebuffer, and retrieve
  473.     //  a pixel that is either one column
  474.     //  left or right of the current one.
  475.     // Add index from colormap to index.
  476.     *dest2 = *dest = colormaps[6*256+dest[fuzzoffset[fuzzpos]]];
  477.  
  478.     // Clamp table lookup index.
  479.     if (++fuzzpos == FUZZTABLE)
  480.         fuzzpos = 0;
  481.  
  482.     dest += SCREENWIDTH;
  483.     dest2 += SCREENWIDTH;
  484.  
  485.     frac += fracstep;
  486.     } while (count--);
  487. }
  488. #endif
  489.  
  490.   
  491.  
  492.  
  493. //
  494. // R_DrawTranslatedColumn
  495. // Used to draw player sprites
  496. //  with the green colorramp mapped to others.
  497. // Could be used with different translation
  498. //  tables, e.g. the lighter colored version
  499. //  of the BaronOfHell, the HellKnight, uses
  500. //  identical sprites, kinda brightened up.
  501. //
  502. byte*    dc_translation;
  503. byte*    translationtables;
  504.  
  505. //#ifndef AMIGA
  506.  
  507. void R_DrawTranslatedColumn (void) 
  508. { 
  509.     int            count; 
  510.     byte*        dest; 
  511.     fixed_t        frac;
  512.     fixed_t        fracstep;     
  513.  
  514.     count = dc_yh - dc_yl; 
  515.     if (count < 0) 
  516.     return; 
  517.                  
  518. #ifdef RANGECHECK 
  519.     if ((unsigned)dc_x >= SCREENWIDTH
  520.     || dc_yl < 0
  521.     || dc_yh >= SCREENHEIGHT)
  522.     {
  523.     I_Error ( "R_DrawColumn: %i to %i at %i",
  524.           dc_yl, dc_yh, dc_x);
  525.     }
  526.     
  527. #endif 
  528.  
  529.  
  530.     // WATCOM VGA specific.
  531.     /* Keep for fixing.
  532.     if (detailshift)
  533.     {
  534.     if (dc_x & 1)
  535.         outp (SC_INDEX+1,12); 
  536.     else
  537.         outp (SC_INDEX+1,3);
  538.     
  539.     dest = destview + dc_yl*80 + (dc_x>>1); 
  540.     }
  541.     else
  542.     {
  543.     outp (SC_INDEX+1,1<<(dc_x&3)); 
  544.  
  545.     dest = destview + dc_yl*80 + (dc_x>>2); 
  546.     }*/
  547.  
  548.     
  549.     // FIXME. As above.
  550.     dest = ylookup[dc_yl] + columnofs[dc_x]; 
  551.  
  552.     // Looks familiar.
  553.     fracstep = dc_iscale; 
  554.     frac = dc_texturemid + (dc_yl-centery)*fracstep; 
  555.  
  556.     // Here we do an additional index re-mapping.
  557.     do 
  558.     {
  559.     // Translation tables are used
  560.     //  to map certain colorramps to other ones,
  561.     //  used with PLAY sprites.
  562.     // Thus the "green" ramp of the player 0 sprite
  563.     //  is mapped to gray, red, black/indigo. 
  564.     *dest = dc_colormap[dc_translation[dc_source[frac>>FRACBITS]]];
  565.     dest += SCREENWIDTH;
  566.     
  567.     frac += fracstep; 
  568.     } while (count--); 
  569. } 
  570.  
  571. //#endif
  572.  
  573.  
  574.  
  575. //
  576. // R_DrawTranslatedColumn
  577. // Used to draw player sprites
  578. //  with the green colorramp mapped to others.
  579. // Could be used with different translation
  580. //  tables, e.g. the lighter colored version
  581. //  of the BaronOfHell, the HellKnight, uses
  582. //  identical sprites, kinda brightened up.
  583. //
  584. byte*    dc_translation;
  585. byte*    translationtables;
  586.  
  587. //#ifndef AMIGA
  588.  
  589. void R_DrawTranslatedColumnLow (void) 
  590. { 
  591.     int            count; 
  592.     byte*        dest; 
  593.     byte*        dest2;
  594.     fixed_t        frac;
  595.     fixed_t        fracstep;     
  596.  
  597.     count = dc_yh - dc_yl; 
  598.     if (count < 0) 
  599.     return; 
  600.                  
  601. #ifdef RANGECHECK 
  602.     if (((unsigned)dc_x << 1) >= SCREENWIDTH
  603.     || dc_yl < 0
  604.     || dc_yh >= SCREENHEIGHT)
  605.     {
  606.     I_Error ( "R_DrawColumn: %i to %i at %i",
  607.           dc_yl, dc_yh, dc_x);
  608.     }
  609.     
  610. #endif 
  611.  
  612.  
  613.     // FIXME. As above.
  614.     dest = ylookup[dc_yl] + columnofs[dc_x << 1]; 
  615.     dest2 = ylookup[dc_yl] + columnofs[(dc_x << 1) + 1];
  616.  
  617.     // Looks familiar.
  618.     fracstep = dc_iscale; 
  619.     frac = dc_texturemid + (dc_yl-centery)*fracstep; 
  620.  
  621.     // Here we do an additional index re-mapping.
  622.     do 
  623.     {
  624.     // Translation tables are used
  625.     //  to map certain colorramps to other ones,
  626.     //  used with PLAY sprites.
  627.     // Thus the "green" ramp of the player 0 sprite
  628.     //  is mapped to gray, red, black/indigo. 
  629.     *dest2 = *dest = dc_colormap[dc_translation[dc_source[frac>>FRACBITS]]];
  630.     dest += SCREENWIDTH;
  631.     dest2 += SCREENWIDTH;
  632.     
  633.     frac += fracstep; 
  634.     } while (count--); 
  635. } 
  636.  
  637. //#endif
  638.  
  639.  
  640.  
  641. //
  642. // R_InitTranslationTables
  643. // Creates the translation tables to map
  644. //  the green color ramp to gray, brown, red.
  645. // Assumes a given structure of the PLAYPAL.
  646. // Could be read from a lump instead.
  647. //
  648. void R_InitTranslationTables (void)
  649. {
  650.     int        i;
  651.     
  652.     translationtables = Z_Malloc (256*3+255, PU_STATIC, 0);
  653.     translationtables = (byte *)(( (int)translationtables + 255 )& ~255);
  654.     
  655.     // translate just the 16 green colors
  656.     for (i=0 ; i<256 ; i++)
  657.     {
  658.     if (i >= 0x70 && i<= 0x7f)
  659.     {
  660.         // map green ramp to gray, brown, red
  661.         translationtables[i] = 0x60 + (i&0xf);
  662.         translationtables [i+256] = 0x40 + (i&0xf);
  663.         translationtables [i+512] = 0x20 + (i&0xf);
  664.     }
  665.     else
  666.     {
  667.         // Keep all other colors as is.
  668.         translationtables[i] = translationtables[i+256] 
  669.         = translationtables[i+512] = i;
  670.     }
  671.     }
  672. }
  673.  
  674.  
  675.  
  676.  
  677. //
  678. // R_DrawSpan 
  679. // With DOOM style restrictions on view orientation,
  680. //  the floors and ceilings consist of horizontal slices
  681. //  or spans with constant z depth.
  682. // However, rotation around the world z axis is possible,
  683. //  thus this mapping, while simpler and faster than
  684. //  perspective correct texture mapping, has to traverse
  685. //  the texture at an angle in all but a few cases.
  686. // In consequence, flats are not stored by column (like walls),
  687. //  and the inner loop has to step in texture space u and v.
  688. //
  689. int            ds_y; 
  690. int            ds_x1; 
  691. int            ds_x2;
  692.  
  693. lighttable_t*        ds_colormap; 
  694.  
  695. fixed_t            ds_xfrac; 
  696. fixed_t            ds_yfrac; 
  697. fixed_t            ds_xstep; 
  698. fixed_t            ds_ystep;
  699.  
  700. // start of a 64*64 tile image 
  701. byte*            ds_source;    
  702.  
  703. // just for profiling
  704. int            dscount;
  705.  
  706.  
  707. //
  708. // Draws the actual span.
  709. // UNUSED.
  710. #ifndef AMIGA
  711. void R_DrawSpan (void) 
  712. { 
  713.     fixed_t        xfrac;
  714.     fixed_t        yfrac; 
  715.     byte*        dest; 
  716.     int            count;
  717.     int            spot; 
  718.      
  719. #ifdef RANGECHECK 
  720.     if (ds_x2 < ds_x1
  721.     || ds_x1<0
  722.     || ds_x2>=SCREENWIDTH  
  723.     || (unsigned)ds_y>SCREENHEIGHT)
  724.     {
  725.     I_Error( "R_DrawSpan: %i to %i at %i",
  726.          ds_x1,ds_x2,ds_y);
  727.     }
  728. //    dscount++; 
  729. #endif 
  730.  
  731.     
  732.     xfrac = ds_xfrac; 
  733.     yfrac = ds_yfrac; 
  734.      
  735.     dest = ylookup[ds_y] + columnofs[ds_x1];
  736.  
  737.     // We do not check for zero spans here?
  738.     count = ds_x2 - ds_x1; 
  739.  
  740.     do 
  741.     {
  742.     // Current texture index in u,v.
  743.     spot = ((yfrac>>(16-6))&(63*64)) + ((xfrac>>16)&63);
  744.  
  745.     // Lookup pixel from flat texture tile,
  746.     //  re-index using light/colormap.
  747.     *dest++ = ds_colormap[ds_source[spot]];
  748.  
  749.     // Next step in u,v.
  750.     xfrac += ds_xstep; 
  751.     yfrac += ds_ystep;
  752.     
  753.     } while (count--); 
  754. } 
  755. #endif
  756.  
  757.  
  758.  
  759. // UNUSED.
  760. // Loop unrolled by 4.
  761. #if 0
  762. void R_DrawSpan (void) 
  763. { 
  764.     unsigned    position, step;
  765.  
  766.     byte*    source;
  767.     byte*    colormap;
  768.     byte*    dest;
  769.     
  770.     unsigned    count;
  771.     usingned    spot; 
  772.     unsigned    value;
  773.     unsigned    temp;
  774.     unsigned    xtemp;
  775.     unsigned    ytemp;
  776.         
  777.     position = ((ds_xfrac<<10)&0xffff0000) | ((ds_yfrac>>6)&0xffff);
  778.     step = ((ds_xstep<<10)&0xffff0000) | ((ds_ystep>>6)&0xffff);
  779.         
  780.     source = ds_source;
  781.     colormap = ds_colormap;
  782.     dest = ylookup[ds_y] + columnofs[ds_x1];     
  783.     count = ds_x2 - ds_x1 + 1; 
  784.     
  785.     while (count >= 4) 
  786.     { 
  787.     ytemp = position>>4;
  788.     ytemp = ytemp & 4032;
  789.     xtemp = position>>26;
  790.     spot = xtemp | ytemp;
  791.     position += step;
  792.     dest[0] = colormap[source[spot]]; 
  793.  
  794.     ytemp = position>>4;
  795.     ytemp = ytemp & 4032;
  796.     xtemp = position>>26;
  797.     spot = xtemp | ytemp;
  798.     position += step;
  799.     dest[1] = colormap[source[spot]];
  800.     
  801.     ytemp = position>>4;
  802.     ytemp = ytemp & 4032;
  803.     xtemp = position>>26;
  804.     spot = xtemp | ytemp;
  805.     position += step;
  806.     dest[2] = colormap[source[spot]];
  807.     
  808.     ytemp = position>>4;
  809.     ytemp = ytemp & 4032;
  810.     xtemp = position>>26;
  811.     spot = xtemp | ytemp;
  812.     position += step;
  813.     dest[3] = colormap[source[spot]]; 
  814.         
  815.     count -= 4;
  816.     dest += 4;
  817.     } 
  818.     while (count > 0) 
  819.     { 
  820.     ytemp = position>>4;
  821.     ytemp = ytemp & 4032;
  822.     xtemp = position>>26;
  823.     spot = xtemp | ytemp;
  824.     position += step;
  825.     *dest++ = colormap[source[spot]]; 
  826.     count--;
  827.     } 
  828. } 
  829. #endif
  830.  
  831.  
  832. #ifndef AMIGA
  833. //
  834. // Again..
  835. //
  836. void R_DrawSpanLow (void) 
  837. { 
  838.     fixed_t        xfrac;
  839.     fixed_t        yfrac; 
  840.     byte*        dest; 
  841.     int            count;
  842.     int            spot; 
  843.      
  844. #ifdef RANGECHECK 
  845.     if (ds_x2 < ds_x1
  846.     || ds_x1<0
  847.     || ds_x2>=SCREENWIDTH  
  848.     || (unsigned)ds_y>SCREENHEIGHT)
  849.     {
  850.     I_Error( "R_DrawSpan: %i to %i at %i",
  851.          ds_x1,ds_x2,ds_y);
  852.     }
  853. //    dscount++; 
  854. #endif 
  855.      
  856.     xfrac = ds_xfrac; 
  857.     yfrac = ds_yfrac; 
  858.  
  859.     // Blocky mode, need to multiply by 2.
  860.     ds_x1 <<= 1;
  861.     ds_x2 <<= 1;
  862.     
  863.     dest = ylookup[ds_y] + columnofs[ds_x1];
  864.   
  865.     
  866.     count = ds_x2 - ds_x1; 
  867.     do 
  868.     { 
  869.     spot = ((yfrac>>(16-6))&(63*64)) + ((xfrac>>16)&63);
  870.     // Lowres/blocky mode does it twice,
  871.     //  while scale is adjusted appropriately.
  872.     *dest++ = ds_colormap[ds_source[spot]]; 
  873.     *dest++ = ds_colormap[ds_source[spot]];
  874.     
  875.     xfrac += ds_xstep; 
  876.     yfrac += ds_ystep; 
  877.  
  878.     } while (count--); 
  879. }
  880. #endif
  881.  
  882. //
  883. // R_InitBuffer 
  884. // Creats lookup tables that avoid
  885. //  multiplies and other hazzles
  886. //  for getting the framebuffer address
  887. //  of a pixel to draw.
  888. //
  889. void
  890. R_InitBuffer
  891. ( int        width,
  892.   int        height ) 
  893. { 
  894.     int        i; 
  895.  
  896.     // Handle resize,
  897.     //  e.g. smaller view windows
  898.     //  with border and/or status bar.
  899.     viewwindowx = (SCREENWIDTH-width) >> 1; 
  900.  
  901.     // Column offset. For windows.
  902.     for (i=0 ; i<width ; i++) 
  903.     columnofs[i] = viewwindowx + i;
  904.  
  905.     // Samw with base row offset.
  906.     if (width == SCREENWIDTH) 
  907.     viewwindowy = 0; 
  908.     else 
  909.     viewwindowy = (SCREENHEIGHT-SBARHEIGHT-height) >> 1; 
  910.  
  911.     // Preclaculate all row offsets.
  912.     for (i=0 ; i<height ; i++) 
  913.     ylookup[i] = screens[0] + (i+viewwindowy)*SCREENWIDTH; 
  914. } 
  915.  
  916.  
  917.  
  918.  
  919. //
  920. // R_FillBackScreen
  921. // Fills the back screen with a pattern
  922. //  for variable screen sizes
  923. // Also draws a beveled edge.
  924. //
  925. void R_FillBackScreen (void) 
  926. { 
  927.     byte*    src;
  928.     byte*    dest; 
  929.     int        x;
  930.     int        y; 
  931.     patch_t*    patch;
  932.  
  933.     // DOOM border patch.
  934.     char    name1[] = "FLOOR7_2";
  935.  
  936.     // DOOM II border patch.
  937.     char    name2[] = "GRNROCK";    
  938.  
  939.     char*    name;
  940.     
  941.     if (scaledviewwidth == 320)
  942.     return;
  943.     
  944.     if ( gamemode == commercial)
  945.     name = name2;
  946.     else
  947.     name = name1;
  948.     
  949.     src = W_CacheLumpName (name, PU_CACHE); 
  950.     dest = screens[1]; 
  951.      
  952.     for (y=0 ; y<SCREENHEIGHT-SBARHEIGHT ; y++) 
  953.     { 
  954.     for (x=0 ; x<SCREENWIDTH/64 ; x++) 
  955.     { 
  956.         memcpy (dest, src+((y&63)<<6), 64); 
  957.         dest += 64; 
  958.     } 
  959.  
  960.     if (SCREENWIDTH&63) 
  961.     { 
  962.         memcpy (dest, src+((y&63)<<6), SCREENWIDTH&63); 
  963.         dest += (SCREENWIDTH&63); 
  964.     } 
  965.     } 
  966.     
  967.     patch = W_CacheLumpName ("brdr_t",PU_CACHE);
  968.  
  969.     for (x=0 ; x<scaledviewwidth ; x+=8)
  970.     V_DrawPatch (viewwindowx+x,viewwindowy-8,1,patch);
  971.     patch = W_CacheLumpName ("brdr_b",PU_CACHE);
  972.  
  973.     for (x=0 ; x<scaledviewwidth ; x+=8)
  974.     V_DrawPatch (viewwindowx+x,viewwindowy+viewheight,1,patch);
  975.     patch = W_CacheLumpName ("brdr_l",PU_CACHE);
  976.  
  977.     for (y=0 ; y<viewheight ; y+=8)
  978.     V_DrawPatch (viewwindowx-8,viewwindowy+y,1,patch);
  979.     patch = W_CacheLumpName ("brdr_r",PU_CACHE);
  980.  
  981.     for (y=0 ; y<viewheight ; y+=8)
  982.     V_DrawPatch (viewwindowx+scaledviewwidth,viewwindowy+y,1,patch);
  983.  
  984.  
  985.     // Draw beveled edge. 
  986.     V_DrawPatch (viewwindowx-8,
  987.          viewwindowy-8,
  988.          1,
  989.          W_CacheLumpName ("brdr_tl",PU_CACHE));
  990.     
  991.     V_DrawPatch (viewwindowx+scaledviewwidth,
  992.          viewwindowy-8,
  993.          1,
  994.          W_CacheLumpName ("brdr_tr",PU_CACHE));
  995.     
  996.     V_DrawPatch (viewwindowx-8,
  997.          viewwindowy+viewheight,
  998.          1,
  999.          W_CacheLumpName ("brdr_bl",PU_CACHE));
  1000.     
  1001.     V_DrawPatch (viewwindowx+scaledviewwidth,
  1002.          viewwindowy+viewheight,
  1003.          1,
  1004.          W_CacheLumpName ("brdr_br",PU_CACHE));
  1005. } 
  1006.  
  1007.  
  1008. //
  1009. // Copy a screen buffer.
  1010. //
  1011. void
  1012. R_VideoErase
  1013. ( unsigned    ofs,
  1014.   int        count ) 
  1015. { 
  1016.   // LFB copy.
  1017.   // This might not be a good idea if memcpy
  1018.   //  is not optiomal, e.g. byte by byte on
  1019.   //  a 32bit CPU, as GNU GCC/Linux libc did
  1020.   //  at one point.
  1021.     memcpy (screens[0]+ofs, screens[1]+ofs, count); 
  1022. } 
  1023.  
  1024.  
  1025. //
  1026. // R_DrawViewBorder
  1027. // Draws the border around the view
  1028. //  for different size windows?
  1029. //
  1030. void
  1031. V_MarkRect
  1032. ( int        x,
  1033.   int        y,
  1034.   int        width,
  1035.   int        height ); 
  1036.  
  1037. void R_DrawViewBorder (void) 
  1038. { 
  1039.     int        top;
  1040.     int        side;
  1041.     int        ofs;
  1042.     int        i; 
  1043.  
  1044.     if (scaledviewwidth == SCREENWIDTH) 
  1045.     return; 
  1046.   
  1047.     top = ((SCREENHEIGHT-SBARHEIGHT)-viewheight)/2; 
  1048.     side = (SCREENWIDTH-scaledviewwidth)/2; 
  1049.  
  1050.     // copy top and one line of left side 
  1051.     R_VideoErase (0, top*SCREENWIDTH+side); 
  1052.  
  1053.     // copy one line of right side and bottom 
  1054.     ofs = (viewheight+top)*SCREENWIDTH-side; 
  1055.     R_VideoErase (ofs, top*SCREENWIDTH+side); 
  1056.  
  1057.     // copy sides using wraparound 
  1058.     ofs = top*SCREENWIDTH + SCREENWIDTH-side; 
  1059.     side <<= 1;
  1060.     
  1061.     for (i=1 ; i<viewheight ; i++) 
  1062.     { 
  1063.     R_VideoErase (ofs, side); 
  1064.     ofs += SCREENWIDTH; 
  1065.     } 
  1066.  
  1067.     // ? 
  1068.     V_MarkRect (0,0,SCREENWIDTH, SCREENHEIGHT-SBARHEIGHT); 
  1069. } 
  1070.  
  1071.  
  1072.